 /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package javacroft.business;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *
 * @author hind
 */
public class Etudiant
{
   private List<UE> sesUE;
   private List<UE> sesAPDJ;
   private List<Notation> sesNotes;
   private List<SemestreEtranger> sesSemestreEtranger;
   private List<PointJury> sesPointJury;
   private Annee sonAnnee;
   private String unPrenom;
   private String unNom;
   private Integer scoreTOEIC;
 

   /**
    * Constructeur
    * @param unNom Nom de l'étudiant
    * @param unPrenom Prénom de l'étudiant
    * @param uneAnnee Année dans laquelle il est inscrit
    * @param score Score TOEIC de l'étudiant
    */
    public Etudiant(String unNom,String unPrenom,Annee uneAnnee,String score)
    {
            this.unNom= unNom;
            this.unPrenom=unPrenom;
            this.sonAnnee=uneAnnee;            
            sesUE = new ArrayList<UE>();
            sesAPDJ = new ArrayList<UE>();
            sesNotes = new ArrayList<Notation>();
            sesSemestreEtranger = new ArrayList<SemestreEtranger>();
            sesPointJury = new ArrayList<PointJury>();
            setTOEIC(score);
    }   

   /**
    * Prénom de l'étudiant
    * @return Son prénom
    */
    public String getPrenom()
    {
       return unPrenom;
    }

    /**
    * Nom de l'étudiant
    * @return Son nom
    */
    public String getNom()
    {
        return unNom;
    }

    public List<Notation> getSesNotes()
    {
        return sesNotes;
    }

    public List<UE> getSesUE()
    {
        return sesUE;
    }

     public List<ECUE> getSesECUE()
    {
        List<ECUE> lesECUE = new ArrayList<ECUE>();

        Iterator iter = sesUE.iterator();

        while (iter.hasNext())
        {
            ((ArrayList)lesECUE).addAll(((UE)iter.next()).getLesECUE());
        }

        return lesECUE;

    }

    public List<Semestre> getSesSemestres()
    {
       return sonAnnee.getLesSemestres();
    }

    public List<PointJury> getPointJury()
    {
        return sesPointJury;
    }

    public List<UE> getLesAPDJ()
    {
        return sesAPDJ;
    }    

    public List<SemestreEtranger> getSesSemestreEtranger()
    {
        return sesSemestreEtranger;
    }

    public Annee getAnnee()
    {
        return sonAnnee;
    }

    public int getScoreTOEIC()
    {
        return scoreTOEIC;
    }

    /*methodes des arraylist*/
    /**
    *  Methode pour calculer la moyene annuelle de l'etudiant
    */   

    /**
     * Calcule la moyenne annuelle de l'étudiant
     * @return Moyenne
     */
    public float calculerMoyenneAnnuelle()
    {
        float cumul=0;
        int nbSem = 0;
        Iterator iter = null;

        iter = getAnnee().getLesSemestres().iterator();

        while(iter.hasNext())
        {
            cumul += calculerMoyenneSemestre((Semestre)iter.next());
            nbSem++;
        }

        return (cumul/nbSem);
    }

    /**
     * Calcule la moyenne de l'UE pour l'étudiant
     * @param ue UE dont on cherche la moyenne
     * @return Moyenne dans l'UE
     */
    public float calculerMoyenneUE(UE ue)
    {
        float cumul = 0;
        int nbMat = 0;
        Iterator iter = null;
        ECUE ecueCourante = null;
        Notation note = null;
        
        if(getSesUE().contains(ue))
        {
            iter = getSesUE().get(getSesUE().indexOf(ue)).getLesECUE().iterator();
            
            while(iter.hasNext())
            {

                ecueCourante = (ECUE)iter.next();
                note = getNoteECUE(ecueCourante);
                
                if(note != null)
                {
                    cumul += (note.getNote()*ecueCourante.getUnCoeff());
                    nbMat++;
                }
            }
        }
        return (cumul);

    }

    /**
     * Calcule la moyenne du semestre
     * @param semestre Semestre dont on cherche la moyenne
     * @return Moyenne
     */
    public float calculerMoyenneSemestre(Semestre semestre)
    {
        float cumul=0;
        int nbUE = 0;
        Iterator iter = null;      

        if(getAnnee().getLesSemestres().contains(semestre))
        {
            iter = getAnnee().getLesSemestres().get(getAnnee().getLesSemestres().indexOf(semestre)).getLesUE().iterator();

            while(iter.hasNext())
            {
                cumul += calculerMoyenneUE((UE)iter.next());
                nbUE++;
            }
        }

        return (cumul/nbUE);
    }

    @Override
    public String toString()
    {
        return this.getNom()+" "+this.getPrenom()+"\nScore TOEIC : "+this.getScoreTOEIC();
    }

    public int compareTo(Etudiant unEtudiant)
    {
         return (this.unNom.compareToIgnoreCase(unEtudiant.getNom()));
    }

    public boolean compareTo(String unNom,String unPrenom)
    {
        return ( (this.unNom.compareToIgnoreCase(unNom) ==0 ) && (this.unPrenom.compareToIgnoreCase(unPrenom) == 0 ) );
    }

    /**
     * @param sesUE the sesUE to set
     */
    public void setSesUE(List<UE> sesUE) {
        this.sesUE = sesUE;
    }

    public void addPointJuryA(Annee uneAnnee, float pj)
    {
        sesPointJury.add(new PointJury(pj,uneAnnee));
    }

    public void addPointJuryS(Semestre semestre, float pj)
    {
         sesPointJury.add(new PointJury(pj,semestre));
    }

    public void ajouterUE(UE uneUE)
    {
        sesUE.add(uneUE);
    }

    public void ajouterSemestreEtranger(Semestre semestre,float moyenne)
    {
        sesSemestreEtranger.add(new SemestreEtranger(semestre, moyenne));
    }

    public void ajouterAPDJuE(UE uneUE)
    {
        sesAPDJ.add(uneUE);
    }

    public void ajouterNote(ECUE uneECUE,Float uneNote,boolean estRattrapage)
    {        
        sesNotes.add(new Notation(uneECUE, uneNote, estRattrapage));
    }

    public void setTOEIC(String score)
    {
        if(!score.startsWith("0"))
        {
            scoreTOEIC = Integer.parseInt(score);
        }
        else
            scoreTOEIC = 0;
    }

    public Notation getNoteECUE(ECUE ecue)
    {
        int i=0;
        Notation notationCourante = null;

        while (i<sesNotes.size() && !(notationCourante = sesNotes.get(i)).getMatiere().compareTo(ecue.getNom()))
        {
            i++;
        }

        if(i<sesNotes.size() && notationCourante != null && (notationCourante = sesNotes.get(i)).getMatiere().compareTo(ecue.getNom()))
           return notationCourante;
        else
           return null;
    }

    public PointJury getPointJurySemestre(Semestre semestre)
    {
        Iterator iter = sesPointJury.iterator();
        PointJury pointJuryCourant = null;

        while (iter.hasNext() && !(pointJuryCourant = ((PointJury)iter.next())).compareTo(semestre))
        {
            continue;
        }

        if(pointJuryCourant != null && pointJuryCourant.compareTo(semestre))        
           return pointJuryCourant;
       
        else
           return null;
    }

     public PointJury getPointJuryAnnee(Annee annee)
    {
        Iterator iter = sesPointJury.iterator();
        PointJury pointJuryCourant = null;

        while (iter.hasNext() && !(pointJuryCourant = ((PointJury)iter.next())).compareTo(annee))
        {
            continue;
        }

       if(pointJuryCourant != null && pointJuryCourant.compareTo(annee))
           return pointJuryCourant;
        else
           return null;
    }
    
    public boolean isSemestreEtranger(Semestre semestre)
    {
        Iterator iter = sesSemestreEtranger.iterator();
        SemestreEtranger semCourant = null;

        while (iter.hasNext() && !(semCourant = ((SemestreEtranger)iter.next())).compareTo(semestre))
        {
            continue;
        }

        if(semCourant == null)
            return false;
        else
            return true;
    }


}
